package com.ourcraft.informationcollectionsystem.service.province.userManage;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ourcraft.informationcollectionsystem.entity.City;
import com.ourcraft.informationcollectionsystem.entity.Company;
import com.ourcraft.informationcollectionsystem.entity.DTO.UserDetailInfo;
import com.ourcraft.informationcollectionsystem.entity.DataReportForm;
import com.ourcraft.informationcollectionsystem.entity.User;
import com.ourcraft.informationcollectionsystem.mapper.*;
import com.ourcraft.informationcollectionsystem.utils.statusCode.DataReportFormStatus;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

import static com.ourcraft.informationcollectionsystem.utils.Encryptor.encryptPassword;

/**
 * 用户管理模块调用的服务实现
 *
 * @author Z0136
 * @since 2023/11/1
 */
@Service
public class UserManageServiceImpl implements UserManageService {
    // 用户初始默认密码
    private final String defaultPwd = encryptPassword("88888888");

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private CompanyMapper companyMapper;
    @Autowired
    private DataReportFormMapper dataReportFormMapper;
    @Autowired
    private CityMapper cityMapper;

    /**
     * 将指定用户账号设置为企业角色账号
     *
     * @param userId 用户Id
     * @return 创建企业信息成功或失败原因
     */
    private String addNewCompany(Integer userId) {
        QueryWrapper<Company> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        // 删除该用户之前的企业信息
        Company formerCompany = companyMapper.selectOne(queryWrapper);
        if (formerCompany != null)
            if (companyMapper.deleteById(formerCompany.getCompanyId()) == 0)
                return "删除原数据失败";
        // 创建新的企业信息
        if (companyMapper.insert(new Company(userId)) == 0)
            return "创建企业用户失败";
        return "success";
    }

    /**
     * 将指定用户账号设置为市角色账号
     *
     * @param userId 用户Id
     * @param city   新的市用户所属市
     * @return 创建市信息成功或失败原因
     */
    private String addNewCity(Integer userId, String city) {
        QueryWrapper<City> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        // 删除之前的市信息
        City formerCity = cityMapper.selectOne(queryWrapper);
        if (formerCity != null)
            if (cityMapper.deleteById(formerCity.getCityId()) == 0)
                return "删除原数据失败";
        // 创建新的市信息
        if (cityMapper.insert(new City(userId, city)) == 0)
            return "创建市用户失败";
        return "success";
    }

    /**
     * 根据需要创建的用户信息创建用户
     *
     * @param roleId 角色Id
     * @param city   用户所属市
     * @return 是否创建成功
     */
    @Override
    public boolean createUser(int roleId, String city) {
        User newUser = new User(defaultPwd, roleId);

        // 设置用户id，以角色id开头的至少五位数
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("role_id", roleId);
        int newId;
        // 第一个该角色用户Id
        if (!userMapper.exists(queryWrapper))
            newId = roleId * 10000 + 1;
            // 该角色新用户Id
        else {
            queryWrapper.orderByDesc("user_id").last("LIMIT 1");
            newId = userMapper.selectOne(queryWrapper).getUserId() + 1;
        }
        newUser.setUserId(newId);

        // 插入新用户
        if (userMapper.insert(newUser) == 0)
            return false;
        Integer userId = newUser.getUserId();

        // 如果是企业用户，创建新企业信息
        if (roleId == 3)
            if (!Objects.equals(addNewCompany(userId), "success")) {
                // 添加失败，撤销创建新用户
                userMapper.deleteById(userId);
                return false;
            }

        // 如果是市管理员，创建新市信息
        if (roleId == 2)
            if (!Objects.equals(addNewCity(userId, city), "success")) {
                // 添加失败，撤销创建新用户
                userMapper.deleteById(userId);
                return false;
            }

        return true;
    }

    /**
     * 获取所有用户的详细信息
     *
     * @return 所有用户的详细信息
     */
    @Override
    public List<UserDetailInfo> getAllUserInfo() {
        // 查询所有企业用户信息
        List<UserDetailInfo> userCompanyInfo = userMapper.selectUserCompanyInfo();
        // 查询所有市用户信息
        List<UserDetailInfo> userCityInfo = userMapper.selectUserCityInfo();
        // 设置市用户名
        userCityInfo.forEach(e -> e.setUserName(e.getUserName() + "管理员"));
        // 查询所有省用户信息
        List<UserDetailInfo> userProvinceInfo = userMapper.selectUserProvinceInfo();
        // 设置省用户名
        userProvinceInfo.forEach(e -> e.setUserName("云南省管理员"));

        List<UserDetailInfo> allUserInfo = new ArrayList<>();
        allUserInfo.addAll(userProvinceInfo);
        allUserInfo.addAll(userCityInfo);
        allUserInfo.addAll(userCompanyInfo);
        return allUserInfo;
    }

    /**
     * 重置用户密码
     *
     * @param userAccount 重置密码的用户账号
     * @return 是否重置成功
     */
    @Override
    public boolean resetUserPassword(int userAccount) {
        User user = new User();
        // 设置默认密码
        user.setUserPassword(defaultPwd);
        user.setUserId(userAccount);
        return userMapper.updateById(user) != 0;
    }

    /**
     * 修改用户角色
     *
     * @param user 修改的用户的详细信息，包含用户Id、用户角色和所属市
     * @return 是否修改成功
     */
    @Override
    public String changeUserRole(UserDetailInfo user) {
        // 最高权限省用户角色不可修改
        if (user.getUserAccount() == 10001)
            return "最高权限省用户角色不可修改";

        User updateUser = new User();
        Integer roleId = user.getUserRole();
        Integer userId = user.getUserAccount();
        updateUser.setRoleId(roleId);
        updateUser.setUserId(userId);
        // 获取用户之前的角色
        int formerRole = userMapper.selectById(userId).getRoleId();
        // 判断formerRole和roleId的关系
        // 企业用户更新为市用户
        if (formerRole == 3 && roleId == 2) {
            // 判断企业用户是否已确定所属市
            if (user.getUserCity() == null)
                return "无法确定该市用户的所属市";
            // 创建新的市用户信息
            String message = addNewCity(userId, user.getUserCity());
            if (!message.equals("success"))
                return message;
        }
        // 市用户更新为企业用户
        else if (formerRole == 2 && roleId == 3) {
            // 创建新的企业用户
            String message = addNewCompany(userId);
            if (!message.equals("success"))
                return message;
        }
        // 省用户更改权限
        else if (formerRole == 1) {
            // 更改为市用户
            if (roleId == 2)
                return "无法确定该市用户的所属市";
            // 更改为企业用户
            if (roleId == 3) {
                // 创建新的企业用户
                String message = addNewCompany(userId);
                if (!message.equals("success"))
                    return message;
            }
        }
        // 将市或企业用户权限变更为省
        else if(formerRole == 2)
            // 删除原来的市信息
            cityMapper.delete(new QueryWrapper<City>().eq("user_id", userId));
        else if(formerRole == 3)
            // 删除原来的企业信息
            companyMapper.delete(new QueryWrapper<Company>().eq("user_id", userId));

        // 更新用户权限
        if (userMapper.updateById(updateUser) == 0)
            return "修改失败";
        return "success";
    }

    /**
     * 修改用户状态
     *
     * @param userId 修改的用户账号
     * @param status 修改后用户状态
     * @return 是否修改成功
     */
    @Override
    public boolean changeUserStatus(int userId, boolean status) {
        // 最高权限省用户不可注销
        if (userId == 10001) return false;

        // 需要注销用户
        if (!status) {
            QueryWrapper<Company> queryWrapper1 = new QueryWrapper<>();
            queryWrapper1.eq("user_id", userId);
            Company company = companyMapper.selectOne(queryWrapper1);
            // 判断当前角色是否为企业用户
            if (company != null) {
                // 获取企业用户ID
                int companyId = company.getCompanyId();
                // 查询该企业是否有已提交调查期表单
                QueryWrapper<DataReportForm> queryWrapper2 = new QueryWrapper<>();
                queryWrapper2.eq("company_id", companyId).ge("form_examine_status", DataReportFormStatus.WAIT_CITY).last("LIMIT 1");
                // 判断查询结果是否为空
                if (dataReportFormMapper.selectCount(queryWrapper2) == 0)
                    // 不存在已提交调查期表单则直接删除用户
                    return userMapper.deleteById(userId) > 0;
            }
            // 企业角色用户直接删除
            else return userMapper.deleteById(userId) > 0;
        }

        // 恢复用户状态为激活
        User user = new User();
        user.setUserStatus(status);
        user.setUserId(userId);
        return userMapper.updateById(user) > 0;
    }
}

